/**
 * Created by Administrator on 2017/3/6.
 */
var config = require('../../config');
var redis = require("redis");
var client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth});

//加入分布式redis锁，至少一个client
var Redlock = require('redlock');
var redlock=new Redlock([client],{
    // the expected clock drift; for more details
    // see http://redis.io/topics/distlock
    driftFactor: 0.01, // time in ms

    // the max number of times Redlock will attempt
    // to lock a resource before erroring
    retryCount:  10,

    // the time in ms between attempts
    retryDelay:  200, // time in ms

    // the max time in ms randomly added to retries
    // to improve performance under high contention
    // see https://www.awsarchitectureblog.com/2015/03/backoff.html
    retryJitter:  200 // time in ms
})


redlock.on('clientError', function(err) {
    console.error('A redis error has occurred:', err);
});



    // client = redis.createClient(50000, '42.51.204.161', {auth_pass: 123456});
client.on('error', function (err) {
    console.log('Erro:', err);
    client.quit();
    //断线重连  redis本身存在断线重连机制，这里不再处理
    // client = redis.createClient(50000, '42.51.204.161', {auth_pass: 123456});
})
client.on('connect', function () {
    console.log('Redis连接成功。')
});
module.exports = {
    /**
     * 设置字符串值
     * @param key
     * @param value
     * @param expire
     * @param callback
     */
    set: function (key, value, expire, callback) {
        // client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});
        try {
            client.set(key, value, function (err, result) {
                if (err) {
                    console.log(err);
                    callback(err, null);
                    // return;
                }
                if (!isNaN(expire) && expire > 0) {
                    client.expire(key, parseInt(expire));
                }

            });
        } catch (err) {
            console.log('保存redis缓存失败');
            callback(err, null);
        }
        // client.quit();
    },

    /**
     * 查询string类型的数据
     * @param key 键
     * @param callBack(err,result)
     */
    get: function (key, callback) {
        // client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});

        try {
            client.get(key, function (err, result) {
                if (err) {
                    console.log(err);
                    callback(err, null)
                    // return;
                }
                callback(null, result);
                // client.quit();
            });
        } catch (err) {
            console.log('获得redis缓存失败');
            callback(err, null);
        }

    },

    /**
     * 查询哈希类型
     *
     */
    getHgetall: function (key, callback) {
        // client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});

        try {
            client.hgetall(key, function (err, obj) {
                if (err) {
                    console.log(err);
                    callback(err, null);
                    // return;
                }
                callback(null, obj);
                // client.quit();
            })

        } catch (err) {
            console.log('获得redis缓存失败');
            callback(err, null);
        }

    }
    ,
    setHset: function (key, obj, callback) {
        // client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});

        try {
            client.hmset(key, obj, function (err, obj) {
                if (err) {
                    console.log(err);
                    callback(err, null);
                    // return;
                }
                client.expire(key, 3600);
                callback(null, obj);
                // client.quit();
            })
            // client.quit();
        } catch (err) {
            console.log('保存redis缓存失败');
            callback(err, null);
        }
    },

    sadd:function (key,value, callback) {
      client.sadd(key,value,function (result) {
          callback(result);
      })
    },

    /**
     * 设置过期时间的对象设置方法
     * @param params   [key, obj,time]
     * @param callback   [err,obj]
     */
    setHsetWithTime: function (params, callback) {
        // key, obj,time
        // client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});

        var key=params[0];
        var obj=params[1];
        var time=params[2];
        try {
            client.hmset(key, obj, function (err, obj) {
                if (err) {
                    console.log(err);
                    callback(err, null);
                    // return;
                }
                if (time) {
                    client.expire(key, time);
                } else {
                    client.expire(key, 3600);

                }

                callback(null, obj);
                // client.quit();
            })
            // client.quit();
        } catch (err) {
            console.log('保存redis缓存失败');
            callback(err, null);
        }
    },
    close: function () {
        try {
            client.quit();
        } catch (err) {
            console.log('redis关闭连接失败')
        }

    }   ,
    /**
     * 分布式事务锁，封装redlock，此处注意redis安装在linux上，否则连接报错。
     * @param key
     * @param callback
     */
    lock:function (key, callback) {
        redlock.lock(key,5000,function (err,result) {
            callback(result);
        })
    }


};


// module.exports = {
//     /**
//      * 设置字符串值
//      * @param key
//      * @param value
//      * @param expire
//      * @param callback
//      */
//     set: function (key, value, expire, callback) {
//         client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});
//         try {
//             client.set(key, value, function (err, result) {
//                 if (err) {
//                     console.log(err);
//                     callback(err, null);
//                     // return;
//                 }
//                 if (!isNaN(expire) && expire > 0) {
//                     client.expire(key, parseInt(expire),function (err, str) {
//                         callback(null, result);
//                         client.quit();
//                     });
//                 }
//
//             });
//         } catch (err) {
//             console.log('保存redis缓存失败')
//         }
//         // client.quit();
//     },
//
//     /**
//      * 查询string类型的数据
//      * @param key 键
//      * @param callBack(err,result)
//      */
//     get: function (key, callback) {
//         client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});
//
//         try {
//             client.get(key, function (err, result) {
//                 if (err) {
//                     console.log(err);
//                     callback(err, null)
//                     // return;
//                 }
//                 callback(null, result);
//                 client.quit();
//             });
//         } catch (err) {
//             console.log('获得redis缓存失败')
//         }
//
//     },
//
//     /**
//      * 查询哈希类型
//      *
//      */
//     getHgetall: function (key, callback) {
//         client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});
//
//         try {
//             client.hgetall(key, function (err, obj) {
//                 if (err) {
//                     console.log(err);
//                     callback(err, null);
//                     // return;
//                 }
//                 callback(null, obj);
//                 client.quit();
//             })
//
//         } catch (err) {
//             console.log('获得redis缓存失败')
//
//         }
//
//     }
//     ,
//     setHset: function (key, obj, callback) {
//         client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});
//
//         try {
//             client.hmset(key, obj, function (err, obj) {
//                 if (err) {
//                     console.log(err);
//                     callback(err, null);
//                     // return;
//                 }
//                 client.expire(key, 3600);
//                 callback(null, obj);
//                 client.quit();
//             })
//             // client.quit();
//         } catch (err) {
//             console.log('保存redis缓存失败')
//         }
//     },
//     /**
//      * 设置过期时间的对象设置方法
//      * @param params   [key, obj,time]
//      * @param callback   [err,obj]
//      */
//     setHsetWithTime: function (params, callback) {
//         // key, obj,time
//         client = redis.createClient(config.redis.port, config.redis.ip, {auth_pass: config.redis.auth_pass});
//
//         var key=params[0];
//         var obj=params[1];
//         var time=params[2];
//         try {
//             client.hmset(key, obj, function (err, obj) {
//                 if (err) {
//                     console.log(err);
//                     callback(err, null);
//                     // return;
//                 }
//                 if (time) {
//                     client.expire(key, time);
//                 } else {
//                     client.expire(key, 3600);
//
//                 }
//
//                 callback(null, obj); client.quit();
//             })
//             // client.quit();
//         } catch (err) {
//             console.log('保存redis缓存失败')
//         }
//     },
//     close: function () {
//         try {
//             client.quit();
//         } catch (err) {
//             console.log('redis关闭连接失败')
//         }
//
//     }
//
//
// };


